Valgono le stesse istruzioni delle esercitazioni precedenti.
Scrivi il programma Python nella cella sotto il testo dell'esercizio (o creane una nuova). Stampa sempre a video il risultato finale per verificare la correttezza dell'esercizio. Talvolta richiamiamo alcuni concetti importanti in una cella di codice sotto il testo dell'esercizio, prova a eseguirla ed eventualmente modificarla per assicurarti di aver capito il necessario.
Nota. Alcuni esercizi potrebbero richiedere una semplice risposta a delle domande. In questo caso potete scrivere la soluzione in una cella di tipo "Markdown".
Valgono le regole delle esercitazioni precedenti.
E' obbligatorio consegnare la soluzione di tutti gli esercizi (tranne quelli marcati come opzionali) entro l'inizio della lezione successiva (in questo caso entro Lunedi' prossimo), nell'apposito assignment su iCorsi. Per consegnare:
Kernel -> Restart & Run All), e controllare che le soluzioni siano quelle attese;File -> Download as...) e consegnare il file risultante.Nel caso non abbiate potuto completare uno o piu' esercizi, descrivete il problema incontrato e consegnate comunque il file con il resto delle soluzioni.
Si consideri lo scatter plot in figura, che riporta la relazione tra la variabile indipendente x e la variabile target y.
Una tra le seguenti 4 rette rappresenta il modello di regressione lineare che minimizza il sum-of-squares error (SSE). Quale? Motivate la vostra risposta.
Soluzione esercizio 1.1
import numpy as np
x1=np.array(range(-10,11))
y1=2*x1+4
w_hat=np.sum((x1-np.mean(x1))*(y1-np.mean(y1)))/np.sum((x1-np.mean(x1))**2)
b_hat=np.mean(y1)-w_hat*np.mean(x1)
import plotly.express as plx
plx.scatter(x1,y1)
x1=np.array(range(-10,11))
y1=2*x1-4
w_hat=np.sum((x1-np.mean(x1))*(y1-np.mean(y1)))/np.sum((x1-np.mean(x1))**2)
b_hat=np.mean(y1)-w_hat*np.mean(x1)
import plotly.express as plx
plx.scatter(x1,y1)
x1=np.array(range(-10,11))
y1=x1-4
w_hat=np.sum((x1-np.mean(x1))*(y1-np.mean(y1)))/np.sum((x1-np.mean(x1))**2)
b_hat=np.mean(y1)-w_hat*np.mean(x1)
import plotly.express as plx
plx.scatter(x1,y1)
Scrivere una funzione Python computePerformance(x,y,w,b) che calcola il SSE e il coefficiente di determinazione $R^2$ tra le osservazioni e la retta di regressione $y = wx + b$.
La funzione riceve come argomenti di ingresso:
e restituisce il SSE e l' $R^2$.
Testate la funzione computePerformance(x,y,w,b) per vari valori di $w$ e $b$ su un set di osservazioni generato in questo modo:
errore = 0.1*np.random.randn(1000)Se non avete fatto errori, dovreste osservare che il SSE è "basso" e l' $R^2$ è "prossimo a 1" per valori di $w$ e $b$ vicini a $3$ e $-1$.
# Solution
import numpy as np
from sklearn.metrics import r2_score
def computePerfomance(x,y,w,b):
y_hat = b + w * x
e = y - y_hat
output= dict({"sse":np.sum(e**2),"r2": r2_score(x,y)})
return output
x=np.random.randn(1000)
errore = 0.1*np.random.randn(1000)
y=3*x-1+errore
computePerfomance(x,y,3,-1)
{'sse': 10.197825082491487, 'r2': -3.7058267843136887}
Il pacchetto Python scikit-learn ci permette di calcolare un modello di regressione lineare (sia semplice che multipla) con pochi comandi e in maniera molto efficiente.
Familiarizzate con i comandi principli si scikit-learn eseguendo le celle di questo esercizio oppure guardano gli esempi disponibili online.
La seguente cella importa il modulo linear_model dal pacchetto scikit-learn dove sono definite classi e metodi necessari per costruire un modello di regressione lineare del tipo y = x*w+b. Una volta importato il modulo linear_model, viene costruito un oggetto linRegr della classe LinearRegression. All'oggetto linRegrviene applicato il metodo fit per ricavare il modello di regressione.
Nota: il metoto fit riceve come parametri di ingresso:
- x: array di dimensione DUE con i valori delle variabili esplicative. L'array ha m righe e n colonne (dove m è il numero di osservazioni, e n è il numero di variabili esplicative. Nota bene: (i) n=1 nel caso di regressione semplice, (ii) x deve sempre essere un array di dimensione DUE!! Se avete un array di dimensione 1, fate il reshape dell'array tramite il comando np.reshape per trasformarlo in un vettore colonna di dimensione DUE)
- y: array con i valori della variabile target di lunghezza m. Nota: y puo' anche essere un array di dimensione 1.
Una volta eseguito il comando fit, potete visualizzare i parametri w e b del modello di regressione accedendo agli attributi coef_ e intercept_ dell'oggetto linRegr.
from sklearn import linear_model
# Definisco l'oggetto della classe LinearRegression
linRegr = linear_model.LinearRegression()
m = len(x) # Numero di osservazioni
x = np.reshape(x,(m,1)) # Trasformo l'array delle variabili esplicative in un array di dimensione 2 (con m righe e 1 colonna)
# Costruisco il modello di regressione lineare
linRegr.fit(x,y)
# Stampo i parametri w e b del modello di regressione
w = linRegr.coef_
b = linRegr.intercept_
print(f"Parametri w: {w}")
print(f"Intercetta b: {b}")
Parametri w: [2.99774425] Intercetta b: -1.0033822069493066
Dato un qualunque set di valori della variabile indipendente x, possiamo usare il modello di regressione lineare appena calcolato per stimare il valore della variabile target y. Basta usare il metodo predict e fornire come ingresso i valori della variabile indipendente.
import plotly.offline as py
import plotly.graph_objs as go
py.init_notebook_mode(connected=True)
# Predico l'uscita per i valori della variabile indipendente x
yhat = linRegr.predict(x)
# Plotto variabile target (vera) e variabile target stimata dal modello di regressione lineare
# ATTENZIONE: quando plottate lo scatter plot con plotly, i valori delle coordinate 'x' e 'y' devono essere array di dimensione UNO!!!!!
trace = [go.Scatter(x = x[:,0], y = y, mode = 'markers', name = 'Variabile target misurata'),
go.Scatter(x = x[:,0], y = yhat, mode = 'markers', name = 'Variabile target stimata')]
layout = go.Layout(xaxis = dict(title = 'x: variabile esplicativa'),
yaxis = dict(title = 'y: variabile target'))
fig = go.Figure(trace, layout)
py.iplot(fig)
Il metodo score fornisce il coefficiente di determinazione $R^2$ per il modello di regressione lineare calcolato e per un set di valori della variabile esplicativa x e della corrispondente variabile target y.
R2Tool = linRegr.score(x,y)
R2Tool
0.9988548563314587
Ripete l'esercizio sulla regressione semplice visto a lezione in cui si analizzava la relazione tra lunghezza della mano e altezza di una persona.
Nello specifico:
y=x*w+b utilizzando il pacchetto scikit-learnR^2 utilizzando il metodo scorepredict per calcolate il valore della funzione y = x*w+b per ogni valore di x. Calcolate il SSE# Punto 1
import pandas as pd
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
# Leggiamo il dataset
df = pd.read_table("http://users.stat.ufl.edu/~winner/data/stature_hand_foot.dat",
delim_whitespace=True, names = ["id", "sex", "stature", "hand", "foot"])
x = df["hand"].values # Variabile esplicativa
y = df["stature"].values # Variabile target
m = len(x)
x = np.reshape(x,(m,1))
# Creiamo oggetto della classe LinearRegression
regLin = linear_model.LinearRegression()
# Calcoliamo modello di regressione lineare
regLin.fit(x,y)
w = regLin.coef_
b = regLin.intercept_
print(f"Modello di regression lineare: y=x{w}+{b}")
Modello di regression lineare: y=x[6.14601322]+451.4775962062031
# Punto 2
predictY=regLin.predict(x)
trace=[go.Scatter(x=x[:,0],y=y, mode='markers', name = 'Variabile target misurata'),go.Scatter(x=x[:,0],y=predictY,mode='markers',name = 'Variabile target predetta')]
layout = go.Layout(xaxis = dict(title = 'x: variabile esplicativa'),
yaxis = dict(title = 'y: variabile target'))
fig = go.Figure(trace, layout)
fig.show()
# Punto 3
regLin.score(x,y)
0.7623590030663299
# Punto 4
from sklearn.metrics import mean_squared_error
mean_squared_error(y,predictY)
2082.3004856701587
Si consideri il dataset kc_house_data.csv disponibile su iCorsi, che contiene informazioni sugli appartamenti venduti da Maggio 2014 a Maggio 2015 nella King County. Tra le informazioni disponibili sono presenti prezzo di vendita, caratteristiche dell'abitazione (es., dimensione dell'abitazione, numero di camere da letto, rapporto tra numero di bagni e camere da letto, etc.). Informazioni sul dataset si possono trovare QUI.
L'obbiettivo di questo esercizio è costruire un modello di regressione lineare (sia semplice che multipla) che spieghi la relazione tra le variabili indipendenti (caratteristiche dell'abitazione) e la variabile target (prezzo di vendita).
Eseguite la cella per caricare il dataset (caricheremo solo l'1% dell'intero dataset). Tramite il comando train_test_split, dividiamo in maniera randomica il dataset appena caricato in 2 datasets disgiunti, che chiameremo dfTrain e dfTest e che costituiranno, rispettivamente, il set di training (usato per costruire il modello di regressione lineare), e il set di test (usato per valutare le performance del modello di regressione costruito). La dimensione del set di training e del set di test sono il 70% e 30% del dataset.
Visualizzate i dataset caricati, guardate quali sono i nomi degli attributi e capite cosa rappresentano, aiutandovi con la descrizione disponibile online al seguente link.
import pandas as pd
import numpy as np
from sklearn import linear_model
from sklearn.model_selection import train_test_split
df = pd.read_csv('data/kc_house_data.csv')
df = df.sample(frac=0.01, random_state=42) # carico solo l'1% del dataset originale
[dfTrain, dfTest] = train_test_split(df, test_size=0.3, random_state=42) # la dimensione del test set è il 30% del dataset
# Visualizziamo come è fatto il dataset
print('Training dataset:')
dfTrain
Training dataset:
| id | date | price | bedrooms | bathrooms | sqft_living | sqft_lot | floors | waterfront | view | ... | grade | sqft_above | sqft_basement | yr_built | yr_renovated | zipcode | lat | long | sqft_living15 | sqft_lot15 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 12838 | 3296000040 | 20140923T000000 | 542000.0 | 3 | 2.50 | 1990 | 15985 | 1.0 | 0 | 0 | ... | 8 | 1540 | 450 | 1964 | 0 | 98007 | 47.6205 | -122.141 | 2470 | 10125 |
| 12618 | 6617500085 | 20150422T000000 | 500000.0 | 4 | 2.50 | 2900 | 5760 | 1.0 | 0 | 0 | ... | 8 | 1660 | 1240 | 1959 | 0 | 98118 | 47.5500 | -122.272 | 2250 | 6098 |
| 4296 | 7116500705 | 20150129T000000 | 156000.0 | 2 | 1.00 | 920 | 5889 | 1.0 | 0 | 0 | ... | 6 | 920 | 0 | 1950 | 0 | 98002 | 47.3012 | -122.218 | 1210 | 6180 |
| 9414 | 5700003630 | 20140630T000000 | 1925000.0 | 5 | 4.25 | 4830 | 8050 | 2.5 | 0 | 2 | ... | 11 | 3710 | 1120 | 1914 | 0 | 98144 | 47.5789 | -122.286 | 4470 | 9194 |
| 6914 | 6821600005 | 20150403T000000 | 710000.0 | 4 | 1.75 | 2120 | 5400 | 1.0 | 0 | 0 | ... | 8 | 1060 | 1060 | 1941 | 0 | 98199 | 47.6501 | -122.395 | 2052 | 6000 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| 8288 | 9828200762 | 20140628T000000 | 650000.0 | 2 | 1.00 | 1050 | 2542 | 1.0 | 0 | 0 | ... | 7 | 880 | 170 | 1904 | 0 | 98122 | 47.6172 | -122.298 | 1620 | 1809 |
| 16941 | 2626119028 | 20150323T000000 | 160000.0 | 3 | 1.00 | 1140 | 3240 | 1.5 | 0 | 0 | ... | 6 | 1140 | 0 | 1910 | 0 | 98014 | 47.7093 | -121.364 | 1140 | 4700 |
| 15473 | 6072400280 | 20140619T000000 | 619850.0 | 4 | 2.50 | 2270 | 9247 | 1.0 | 0 | 0 | ... | 8 | 1500 | 770 | 1972 | 0 | 98006 | 47.5602 | -122.176 | 2270 | 9163 |
| 2350 | 3298201170 | 20141110T000000 | 350000.0 | 3 | 1.00 | 940 | 7811 | 1.0 | 0 | 0 | ... | 6 | 940 | 0 | 1959 | 0 | 98008 | 47.6195 | -122.118 | 1180 | 7490 |
| 14984 | 4136960010 | 20150327T000000 | 480000.0 | 5 | 3.50 | 3480 | 12821 | 2.0 | 0 | 2 | ... | 10 | 2890 | 590 | 2004 | 0 | 98092 | 47.2641 | -122.215 | 3400 | 9870 |
151 rows × 21 columns
Utilizzando il dataset di training dfTrain caricato prima, costruite un modello di regressione lineare semplice che spieghi la relazione tra la variabile target price (prezzo di vendita in $) e la variabile esplicativa sqft_living (dimensione dell'abitazione in square feet).
Nello specifico, si eseguano i seguenti punti:
y=x*w+b(Hint: usare i comandi del pacchetto scikit-learn)y = x*w+b per ogni valore di x del training set e del test set (Hint: usate il comando predict). Si plottino, in 2 figure separate, i residui sul training test e sul test set.R^2e il SSE sia sul training set che sul test set.Nota: Si esegua la cella sotto per estrarre dal dataset di training e test la variabile target price e la variabile esplicativa sqft_living
# Carichiamo le variabili che ci interessano
yTrain = dfTrain['price'].values
xTrain = dfTrain['sqft_living'].values
yTest = dfTest['price'].values
xTest = dfTest['sqft_living'].values
print(f"Length of trainig dataset: {len(yTrain)}")
print(f"Length of test dataset: {len(yTest)}")
# Facciamo il reshape delle variabili esplicative per avere array di dimensione 2 con m righe e 1 colonna
mTrain = len(xTrain)
mTest = len(xTest)
xTrain = np.reshape(xTrain,(mTrain,1))
xTest = np.reshape(xTest,(mTest,1))
Length of trainig dataset: 151 Length of test dataset: 65
# Solution (Punto 1)
trace=[go.Scatter(x=xTrain[:,0],y=yTrain,mode="markers")]
layout = go.Layout(xaxis = dict(title = 'sqft_living'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
# Solution (Punto 2)
regLin= linear_model.LinearRegression()
regLin.fit(xTrain,yTrain)
print(f"w={regLin.coef_} b={regLin.intercept_}")
w=[236.68349315] b=38436.72043428547
# Solution (Punto 3)
prediction=regLin.predict(xTrain)
trace=[go.Scatter(x=xTrain[:,0],y=yTrain,mode="markers",name="dataset data"),go.Scatter(x=xTrain[:,0],y=prediction,mode="markers", name="prediction")]
layout = go.Layout(xaxis = dict(title = 'sqft_living'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
trace=[go.Scatter(x=xTrain[:,0],y=yTrain-prediction,mode="markers",name="residual"),go.Scatter(x=xTrain[:,0],y=prediction,mode="markers", name="regretion line")]
layout = go.Layout(xaxis = dict(title = 'sqft_living'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
# Solution (Punto 4)
regLin= linear_model.LinearRegression()
regLin.fit(xTest,yTest)
prediction=regLin.predict(xTest)
trace=[go.Scatter(x=xTest[:,0],y=yTest,mode="markers",name="dataset data"),go.Scatter(x=xTest[:,0],y=prediction,mode="markers", name="prediction")]
layout = go.Layout(xaxis = dict(title = 'sqft_living'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
trace=[go.Scatter(x=xTest[:,0],y=yTest-prediction,mode="markers",name="residual"),go.Scatter(x=xTest[:,0],y=prediction,mode="markers", name="regretion line")]
layout = go.Layout(xaxis = dict(title = 'sqft_living'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
# Solution (Punto 5)
print(f"train r^2= {regLin.score(xTrain,yTrain)}")
print(f"test r^2= {regLin.score(xTest,yTest)}")
train r^2= 0.5196643046455451 test r^2= 0.3700267105716897
Si ripetano i punti dell'esercizio precedente, utilizzando come variabile target sempre il prezzo di vendita, ma come variabile esplicativa non piu' la dimensione dell'abitazione, ma la variabile grade. La variabile grade assume valori tra 1 e 13 e rappresenta la classe di appartenenza dell'abitazione data dalla King County sulla base di una perizia imparziale.
# Solution (punto 0: Carichiamo le variabili che ci interessano)
yTrain = dfTrain['price'].values
xTrain = dfTrain['grade'].values
yTest = dfTest['price'].values
xTest = dfTest['grade'].values
# Facciamo il reshape delle variabili esplicative per avere array di dimensione 2 con m righe e 1 colonna
mTrain = len(xTrain)
mTest = len(xTest)
xTrain = np.reshape(xTrain,(mTrain,1))
xTest = np.reshape(xTest,(mTest,1))
# Solution (Punto 1)
trace=[go.Scatter(x=xTrain[:,0],y=yTrain,mode="markers")]
layout = go.Layout(xaxis = dict(title = 'sqft_living'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
# Solution (Punto 2)
regLin= linear_model.LinearRegression()
regLin.fit(xTrain,yTrain)
print(f"w={regLin.coef_} b={regLin.intercept_}")
w=[182811.66205833] b=-851070.4108805379
# Solution (Punto 3)
prediction=regLin.predict(xTrain)
trace=[go.Scatter(x=xTrain[:,0],y=yTrain,mode="markers",name="dataset data"),go.Scatter(x=xTrain[:,0],y=prediction,mode="markers", name="prediction")]
layout = go.Layout(xaxis = dict(title = 'grade'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
trace=[go.Scatter(x=xTrain[:,0],y=yTrain-prediction,mode="markers",name="residual"),go.Scatter(x=xTrain[:,0],y=prediction,mode="markers", name="regretion line")]
layout = go.Layout(xaxis = dict(title = 'grade'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
# Solution (Punto 4)
regLin= linear_model.LinearRegression()
regLin.fit(xTest,yTest)
prediction=regLin.predict(xTest)
trace=[go.Scatter(x=xTest[:,0],y=yTest,mode="markers",name="dataset data"),go.Scatter(x=xTest[:,0],y=prediction,mode="markers", name="prediction")]
layout = go.Layout(xaxis = dict(title = 'grade'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
trace=[go.Scatter(x=xTest[:,0],y=yTest-prediction,mode="markers",name="residual"),go.Scatter(x=xTest[:,0],y=prediction,mode="markers", name="regretion line")]
layout = go.Layout(xaxis = dict(title = 'grade'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
# Solution (Punto 5)
print(f"train r^2= {regLin.score(xTrain,yTrain)}")
print(f"test r^2= {regLin.score(xTest,yTest)}")
train r^2= 0.5464482507344866 test r^2= 0.43453224414792224
Dagli esercizi precedenti abbiamo notato che c'è una relazione tra la variabile price e le variabili eslicative sqft_living (dimensione dell'appartamento) e grade (classe di appartenenza dell'abitazione). Sino ad ora, queste relazioni sono state descritte (in maniera piu' o meno accurata) da 2 modelli indipendenti di regressione lineare semplice.
In questa parte dell'esercizio useremo le due variabili esplicative sqft_living e grade contemporaneamente per provare a spiegare la variabile target price.
Nello specifico, utilizzando sempre il dataset di training dfTrain caricato prima, si vuole costruire un unico modello di regressione lineare multipla che spieghi la relazione tra la variabile target e le 2 variabili splicative sqft_living e grade.
Si eseguano i seguenti punti:
y=x*w+b = sqft_living*w1 + grade*w2 + by = x*w+b per ogni valore di x del training set e del test set. Si plottino, in 2 figure separate, i residui sul training test e sul test set.R^2e il SSE sia sul training set che sul test set. Il coefficiente $R^2$ del modello di regressione lineare multipla è piu' alto rispetto all' $R^2$ ottenuto dai singoli modelli di regressione lineare semplice? Quale tra i 3 modelli di regressione lineare calcolati sino ad ora (2 modelli di regressione lineare semplice calcolati al punto 2.1 e 2.2 e il modello di regressione lineare multipla calcolato ora) predice meglio il prezzo di vendita delle case? Hint: Guardare l' $R^2$ sui dati di test.Nota: Si esegua la cella sotto per caricare le variabile esplicative in un unico array a DUE dimensione, con m righe e 2 colonne.
xTrain = dfTrain[['sqft_living', 'grade']].values
xTest = dfTest[['sqft_living', 'grade']].values
xTrain
array([[1990, 8],
[2900, 8],
[ 920, 6],
[4830, 11],
[2120, 8],
[2200, 7],
[1410, 7],
[2390, 9],
[2420, 8],
[2481, 8],
[4060, 10],
[2820, 10],
[ 840, 5],
[1520, 6],
[2440, 8],
[1090, 7],
[3590, 9],
[ 830, 6],
[2460, 7],
[1640, 8],
[2380, 8],
[1010, 7],
[2220, 7],
[2620, 9],
[3460, 9],
[3770, 11],
[1180, 6],
[1650, 6],
[1750, 8],
[1260, 6],
[1540, 7],
[3270, 8],
[1280, 6],
[3920, 9],
[1040, 7],
[1129, 7],
[2590, 9],
[2830, 10],
[1240, 6],
[1640, 7],
[1930, 7],
[1680, 7],
[1520, 7],
[2690, 9],
[ 520, 5],
[2970, 8],
[1460, 6],
[3180, 8],
[2550, 9],
[1850, 8],
[4120, 10],
[2230, 8],
[2800, 8],
[2330, 9],
[1430, 7],
[1830, 8],
[1290, 6],
[1140, 6],
[2630, 9],
[1600, 7],
[2070, 8],
[1060, 6],
[1347, 7],
[2000, 7],
[ 970, 7],
[1460, 7],
[1010, 6],
[2120, 8],
[2260, 7],
[ 910, 6],
[2790, 8],
[1610, 7],
[3680, 8],
[1790, 7],
[4285, 10],
[1270, 8],
[1540, 7],
[1580, 8],
[1330, 6],
[1650, 7],
[1710, 7],
[5860, 10],
[4560, 12],
[1700, 7],
[1560, 6],
[3540, 9],
[1520, 7],
[2160, 8],
[1410, 6],
[2290, 7],
[2160, 9],
[1340, 7],
[1800, 7],
[1120, 7],
[2050, 7],
[1500, 7],
[3220, 9],
[1970, 7],
[1140, 7],
[1600, 8],
[1960, 7],
[2790, 9],
[2980, 8],
[2160, 7],
[4360, 10],
[ 850, 5],
[1670, 8],
[1810, 7],
[1390, 7],
[1590, 7],
[2400, 7],
[2290, 8],
[1300, 8],
[2080, 8],
[1630, 7],
[1530, 7],
[2200, 8],
[2560, 8],
[1620, 6],
[1510, 7],
[1180, 7],
[5710, 11],
[3150, 9],
[2590, 9],
[2550, 8],
[2110, 7],
[1750, 7],
[2540, 8],
[2720, 9],
[3600, 8],
[2900, 8],
[2100, 9],
[2260, 7],
[1410, 7],
[3060, 8],
[1830, 7],
[2530, 8],
[1330, 7],
[2090, 7],
[2370, 8],
[1800, 8],
[1110, 6],
[1740, 8],
[1910, 7],
[2280, 7],
[1610, 7],
[1050, 7],
[1140, 6],
[2270, 8],
[ 940, 6],
[3480, 10]])
# Hint (3D scatter plot)
x = np.random.randn(1000)
y = np.random.randn(1000)
z = x**2 + y
trace = go.Scatter3d(x = x, y = y, z = z, mode = 'markers', marker = dict(size = 3) )
layout = go.Layout(scene = dict(xaxis = dict(title = 'x'), yaxis = dict(title = 'y'), zaxis = dict(title = 'z')))
fig = go.Figure([trace], layout)
py.iplot(fig)
# Hint (Disegnare piano nello spazio che passa per punti allineati)
x = np.array([1,2,3])
y = np.array([1,2,3])
z = np.zeros((3,3))
for ind1 in range(len(x)):
for ind2 in range(len(y)):
z[ind1,ind2] = 5*x[ind1] + 10*y[ind2] - 0.4 # Equazione del piano
trace = go.Surface(x = x, y = y, z = z)
layout = go.Layout(scene = dict(xaxis = dict(title = 'x'), yaxis = dict(title = 'y'), zaxis = dict(title = 'z')))
fig = go.Figure([trace], layout)
py.iplot(fig)
# Solution (punto 1)
# Hint (3D scatter plot)
x = xTrain[0]
y = xTrain[1]
z = x*y
trace = go.Scatter3d(x = x, y = y, z = z, mode = 'markers', marker = dict(size = 3) )
layout = go.Layout(scene = dict(xaxis = dict(title = 'x'), yaxis = dict(title = 'y'), zaxis = dict(title = 'z')))
fig = go.Figure([trace], layout)
py.iplot(fig)
# Solution (punto 2)
regLin= linear_model.LinearRegression()
regLin.fit(xTrain,yTrain)
print(f"w1={regLin.coef_[0]} w2={regLin.coef_[1]} b={regLin.intercept_}")
w1=116.93347794762856 w2=108107.19143816349 b=-530314.3651233781
# Solution (punto 3)
x = xTrain[0]
y =xTrain[1]
z = np.zeros((3,3))
for ind1 in range(len(x)):
for ind2 in range(len(y)):
z[ind1,ind2] = regLin.coef_[0]*x[ind1] + regLin.coef_[1]*y[ind2] - regLin.intercept_# Equazione del piano
trace = go.Surface(x = x, y = y, z = z)
layout = go.Layout(scene = dict(xaxis = dict(title = 'x'), yaxis = dict(title = 'y'), zaxis = dict(title = 'z')))
fig = go.Figure([trace], layout)
py.iplot(fig)
# Solution (Punto 4)
regLin= linear_model.LinearRegression()
regLin.fit(xTest,yTest)
prediction=regLin.predict(xTest)
trace=[go.Scatter(x=xTest[:,0],y=yTest,mode="markers",name="dataset data"),go.Scatter(x=xTest[:,0],y=prediction,mode="markers", name="prediction")]
layout = go.Layout(xaxis = dict(title = 'grade'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
trace=[go.Scatter(x=xTest[:,0],y=yTest-prediction,mode="markers",name="residual"),go.Scatter(x=xTest[:,0],y=prediction,mode="markers", name="regretion line")]
layout = go.Layout(xaxis = dict(title = 'grade'),
yaxis = dict(title = 'price'))
fig=go.Figure(trace,layout)
fig.show()
# Solution (punto 5)
print(f"train r^2= {regLin.score(xTrain,yTrain)}")
print(f"test r^2= {regLin.score(xTest,yTest)}")
train r^2= 0.579652412165909 test r^2= 0.45205102967967925